home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / share / gettext / intl / langprefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  2010-09-19  |  12.5 KB  |  356 lines
  1. /* Determine the user's language preferences.
  2.    Copyright (C) 2004-2007 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify it
  5.    under the terms of the GNU Library General Public License as published
  6.    by the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.    Library General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU Library General Public
  15.    License along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  17.    USA.  */
  18.  
  19. /* Written by Bruno Haible <bruno@clisp.org>.
  20.    Win32 code originally by Michele Cicciotti <hackbunny@reactos.com>.  */
  21.  
  22. #ifdef HAVE_CONFIG_H
  23. # include <config.h>
  24. #endif
  25.  
  26. #include <stdlib.h>
  27.  
  28. #if HAVE_CFPREFERENCESCOPYAPPVALUE
  29. # include <string.h>
  30. # include <CoreFoundation/CFPreferences.h>
  31. # include <CoreFoundation/CFPropertyList.h>
  32. # include <CoreFoundation/CFArray.h>
  33. # include <CoreFoundation/CFString.h>
  34. extern void _nl_locale_name_canonicalize (char *name);
  35. #endif
  36.  
  37. #if defined _WIN32 || defined __WIN32__
  38. # define WIN32_NATIVE
  39. #endif
  40.  
  41. #ifdef WIN32_NATIVE
  42. # define WIN32_LEAN_AND_MEAN
  43. # include <windows.h>
  44.  
  45. # ifndef MUI_LANGUAGE_NAME
  46. # define MUI_LANGUAGE_NAME 8
  47. # endif
  48. # ifndef STATUS_BUFFER_OVERFLOW
  49. # define STATUS_BUFFER_OVERFLOW 0x80000005
  50. # endif
  51.  
  52. extern void _nl_locale_name_canonicalize (char *name);
  53. extern const char *_nl_locale_name_from_win32_LANGID (LANGID langid);
  54. extern const char *_nl_locale_name_from_win32_LCID (LCID lcid);
  55.  
  56. /* Get the preferences list through the MUI APIs. This works on Windows Vista
  57.    and newer.  */
  58. static const char *
  59. _nl_language_preferences_win32_mui (HMODULE kernel32)
  60. {
  61.   /* DWORD GetUserPreferredUILanguages (ULONG dwFlags,
  62.                                         PULONG pulNumLanguages,
  63.                                         PWSTR pwszLanguagesBuffer,
  64.                                         PULONG pcchLanguagesBuffer);  */
  65.   typedef DWORD (WINAPI *GetUserPreferredUILanguages_func) (ULONG, PULONG, PWSTR, PULONG);
  66.   GetUserPreferredUILanguages_func p_GetUserPreferredUILanguages;
  67.  
  68.   p_GetUserPreferredUILanguages =
  69.    (GetUserPreferredUILanguages_func)
  70.    GetProcAddress (kernel32, "GetUserPreferredUILanguages");
  71.   if (p_GetUserPreferredUILanguages != NULL)
  72.     {
  73.       ULONG num_languages;
  74.       ULONG bufsize;
  75.       DWORD ret;
  76.  
  77.       bufsize = 0;
  78.       ret = p_GetUserPreferredUILanguages (MUI_LANGUAGE_NAME,
  79.                                            &num_languages,
  80.                                            NULL, &bufsize);
  81.       if (ret == 0
  82.           && GetLastError () == STATUS_BUFFER_OVERFLOW
  83.           && bufsize > 0)
  84.         {
  85.           WCHAR *buffer = (WCHAR *) malloc (bufsize * sizeof (WCHAR));
  86.           if (buffer != NULL)
  87.             {
  88.               ret = p_GetUserPreferredUILanguages (MUI_LANGUAGE_NAME,
  89.                                                    &num_languages,
  90.                                                    buffer, &bufsize);
  91.               if (ret)
  92.                 {
  93.                   /* Convert the list from NUL-delimited WCHAR[] Win32 locale
  94.                      names to colon-delimited char[] Unix locale names.
  95.                      We assume that all these locale names are in ASCII,
  96.                      nonempty and contain no colons.  */
  97.                   char *languages =
  98.                     (char *) malloc (bufsize + num_languages * 10 + 1);
  99.                   if (languages != NULL)
  100.                     {
  101.                       const WCHAR *p = buffer;
  102.                       char *q = languages;
  103.                       ULONG i;
  104.                       for (i = 0; i < num_languages; i++)
  105.                         {
  106.                           char *q1;
  107.                           char *q2;
  108.  
  109.                           q1 = q;
  110.                           if (i > 0)
  111.                             *q++ = ':';
  112.                           q2 = q;
  113.                           for (; *p != (WCHAR)'\0'; p++)
  114.                             {
  115.                               if ((unsigned char) *p != *p || *p == ':')
  116.                                 {
  117.                                   /* A non-ASCII character or a colon inside
  118.                                      the Win32 locale name! Punt.  */
  119.                                   q = q1;
  120.                                   break;
  121.                                 }
  122.                               *q++ = (unsigned char) *p;
  123.                             }
  124.                           if (q == q1)
  125.                             /* An unexpected Win32 locale name occurred.  */
  126.                             break;
  127.                           *q = '\0';
  128.                           _nl_locale_name_canonicalize (q2);
  129.                           q = q2 + strlen (q2);
  130.                           p++;
  131.                         }
  132.                       *q = '\0';
  133.                       if (q > languages)
  134.                         {
  135.                           free (buffer);
  136.                           return languages;
  137.                         }
  138.                       free (languages);
  139.                     }
  140.                 }
  141.               free (buffer);
  142.             }
  143.         }
  144.     }
  145.   return NULL;
  146. }
  147.  
  148. /* Get a preference.  This works on Windows ME and newer.  */
  149. static const char *
  150. _nl_language_preferences_win32_ME (HMODULE kernel32)
  151. {
  152.   /* LANGID GetUserDefaultUILanguage (void);  */
  153.   typedef LANGID (WINAPI *GetUserDefaultUILanguage_func) (void);
  154.   GetUserDefaultUILanguage_func p_GetUserDefaultUILanguage;
  155.  
  156.   p_GetUserDefaultUILanguage =
  157.    (GetUserDefaultUILanguage_func)
  158.    GetProcAddress (kernel32, "GetUserDefaultUILanguage");
  159.   if (p_GetUserDefaultUILanguage != NULL)
  160.     return _nl_locale_name_from_win32_LANGID (p_GetUserDefaultUILanguage ());
  161.   return NULL;
  162. }
  163.  
  164. /* Get a preference.  This works on Windows 95 and newer.  */
  165. static const char *
  166. _nl_language_preferences_win32_95 ()
  167. {
  168.   HKEY desktop_resource_locale_key;
  169.  
  170.   if (RegOpenKeyExA (HKEY_CURRENT_USER,
  171.                      "Control Panel\\Desktop\\ResourceLocale",
  172.                      0, KEY_QUERY_VALUE, &desktop_resource_locale_key)
  173.       == NO_ERROR)
  174.     {
  175.       DWORD type;
  176.       char data[8 + 1];
  177.       DWORD data_size = sizeof (data);
  178.       DWORD ret;
  179.  
  180.       ret = RegQueryValueExA (desktop_resource_locale_key, NULL, NULL,
  181.                               &type, data, &data_size);
  182.       RegCloseKey (desktop_resource_locale_key);
  183.  
  184.       if (ret == NO_ERROR)
  185.         {
  186.           /* We expect a string, at most 8 bytes long, that parses as a
  187.              hexadecimal number.  */
  188.           if (type == REG_SZ
  189.               && data_size <= sizeof (data)
  190.               && (data_size < sizeof (data)
  191.                   || data[sizeof (data) - 1] == '\0'))
  192.             {
  193.               LCID lcid;
  194.               char *endp;
  195.               /* Ensure it's NUL terminated.  */
  196.               if (data_size < sizeof (data))
  197.                 data[data_size] = '\0';
  198.               /* Parse it as a hexadecimal number.  */
  199.               lcid = strtoul (data, &endp, 16);
  200.               if (endp > data && *endp == '\0')
  201.                 return _nl_locale_name_from_win32_LCID (lcid);
  202.             }
  203.         }
  204.     }
  205.   return NULL;
  206. }
  207.  
  208. /* Get the system's preference.  This can be used as a fallback.  */
  209. static BOOL CALLBACK
  210. ret_first_language (HMODULE h, LPCSTR type, LPCSTR name, WORD lang, LONG_PTR param)
  211. {
  212.   *(const char **)param = _nl_locale_name_from_win32_LANGID (lang);
  213.   return FALSE;
  214. }
  215. static const char *
  216. _nl_language_preferences_win32_system (HMODULE kernel32)
  217. {
  218.   const char *languages = NULL;
  219.   /* Ignore the warning on mingw here. mingw has a wrong definition of the last
  220.      parameter type of ENUMRESLANGPROC.  */
  221.   EnumResourceLanguages (kernel32, RT_VERSION, MAKEINTRESOURCE (1),
  222.                          ret_first_language, (LONG_PTR)&languages);
  223.   return languages;
  224. }
  225.  
  226. #endif
  227.  
  228. /* Determine the user's language preferences, as a colon separated list of
  229.    locale names in XPG syntax
  230.      language[_territory][.codeset][@modifier]
  231.    The result must not be freed; it is statically allocated.
  232.    The LANGUAGE environment variable does not need to be considered; it is
  233.    already taken into account by the caller.  */
  234.  
  235. const char *
  236. _nl_language_preferences_default (void)
  237. {
  238. #if HAVE_CFPREFERENCESCOPYAPPVALUE /* MacOS X 10.2 or newer */
  239.   {
  240.     /* Cache the preferences list, since CoreFoundation calls are expensive.  */
  241.     static const char *cached_languages;
  242.     static int cache_initialized;
  243.  
  244.     if (!cache_initialized)
  245.       {
  246.         CFTypeRef preferences =
  247.           CFPreferencesCopyAppValue (CFSTR ("AppleLanguages"),
  248.                                      kCFPreferencesCurrentApplication);
  249.         if (preferences != NULL
  250.             && CFGetTypeID (preferences) == CFArrayGetTypeID ())
  251.           {
  252.             CFArrayRef prefArray = (CFArrayRef)preferences;
  253.             int n = CFArrayGetCount (prefArray);
  254.             char buf[256];
  255.             size_t size = 0;
  256.             int i;
  257.  
  258.             for (i = 0; i < n; i++)
  259.               {
  260.                 CFTypeRef element = CFArrayGetValueAtIndex (prefArray, i);
  261.                 if (element != NULL
  262.                     && CFGetTypeID (element) == CFStringGetTypeID ()
  263.                     && CFStringGetCString ((CFStringRef)element,
  264.                                            buf, sizeof (buf),
  265.                                            kCFStringEncodingASCII))
  266.                   {
  267.                     _nl_locale_name_canonicalize (buf);
  268.                     size += strlen (buf) + 1;
  269.                     /* Most GNU programs use msgids in English and don't ship
  270.                        an en.mo message catalog.  Therefore when we see "en"
  271.                        in the preferences list, arrange for gettext() to
  272.                        return the msgid, and ignore all further elements of
  273.                        the preferences list.  */
  274.                     if (strcmp (buf, "en") == 0)
  275.                       break;
  276.                   }
  277.                 else
  278.                   break;
  279.               }
  280.             if (size > 0)
  281.               {
  282.                 char *languages = (char *) malloc (size);
  283.  
  284.                 if (languages != NULL)
  285.                   {
  286.                     char *p = languages;
  287.  
  288.                     for (i = 0; i < n; i++)
  289.                       {
  290.                         CFTypeRef element =
  291.                           CFArrayGetValueAtIndex (prefArray, i);
  292.                         if (element != NULL
  293.                             && CFGetTypeID (element) == CFStringGetTypeID ()
  294.                             && CFStringGetCString ((CFStringRef)element,
  295.                                                    buf, sizeof (buf),
  296.                                                    kCFStringEncodingASCII))
  297.                           {
  298.                             _nl_locale_name_canonicalize (buf);
  299.                             strcpy (p, buf);
  300.                             p += strlen (buf);
  301.                             *p++ = ':';
  302.                             if (strcmp (buf, "en") == 0)
  303.                               break;
  304.                           }
  305.                         else
  306.                           break;
  307.                       }
  308.                     *--p = '\0';
  309.  
  310.                     cached_languages = languages;
  311.                   }
  312.               }
  313.           }
  314.         cache_initialized = 1;
  315.       }
  316.     if (cached_languages != NULL)
  317.       return cached_languages;
  318.   }
  319. #endif
  320.  
  321. #ifdef WIN32_NATIVE
  322.   {
  323.     /* Cache the preferences list, since computing it is expensive.  */
  324.     static const char *cached_languages;
  325.     static int cache_initialized;
  326.  
  327.     /* Activate the new code only when the GETTEXT_MUI environment variable is
  328.        set, for the time being, since the new code is not well tested.  */
  329.     if (!cache_initialized && getenv ("GETTEXT_MUI") != NULL)
  330.       {
  331.         const char *languages = NULL;
  332.         HMODULE kernel32 = GetModuleHandle ("kernel32");
  333.  
  334.         if (kernel32 != NULL)
  335.           languages = _nl_language_preferences_win32_mui (kernel32);
  336.  
  337.         if (languages == NULL && kernel32 != NULL)
  338.           languages = _nl_language_preferences_win32_ME (kernel32);
  339.  
  340.         if (languages == NULL)
  341.           languages = _nl_language_preferences_win32_95 ();
  342.  
  343.         if (languages == NULL && kernel32 != NULL)
  344.           languages = _nl_language_preferences_win32_system (kernel32);
  345.  
  346.         cached_languages = languages;
  347.         cache_initialized = 1;
  348.       }
  349.     if (cached_languages != NULL)
  350.       return cached_languages;
  351.   }
  352. #endif
  353.  
  354.   return NULL;
  355. }
  356.